export namespace comdto {
	
	export class AppInfo {
	    id?: number;
	    tool_name?: string;
	    tool_icon?: string;
	    tool_icon_color?: string;
	    prompt?: string;
	    input_count?: number;
	    use_nums: number;
	    start_nums?: number;
	    share_user_id: number;
	    share_user_name: string;
	    tag_ids: string;
	    complete_do?: string;
	    // Go type: time
	    created_at: any;
	    // Go type: time
	    updated_at: any;
	
	    static createFrom(source: any = {}) {
	        return new AppInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.input_count = source["input_count"];
	        this.use_nums = source["use_nums"];
	        this.start_nums = source["start_nums"];
	        this.share_user_id = source["share_user_id"];
	        this.share_user_name = source["share_user_name"];
	        this.tag_ids = source["tag_ids"];
	        this.complete_do = source["complete_do"];
	        this.created_at = this.convertValues(source["created_at"], null);
	        this.updated_at = this.convertValues(source["updated_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class AppTagInfo {
	    id: number;
	    Name: string;
	    IsEnabled: boolean;
	    Applications: number;
	    // Go type: time
	    created_at: any;
	
	    static createFrom(source: any = {}) {
	        return new AppTagInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.Name = source["Name"];
	        this.IsEnabled = source["IsEnabled"];
	        this.Applications = source["Applications"];
	        this.created_at = this.convertValues(source["created_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class EmailCodeDtoSend {
	    code_type: string;
	    to_email: string;
	
	    static createFrom(source: any = {}) {
	        return new EmailCodeDtoSend(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code_type = source["code_type"];
	        this.to_email = source["to_email"];
	    }
	}
	export class FindExtra {
	    order_by_column: string;
	    order_by_desc?: boolean;
	    limit?: number;
	    offset?: number;
	
	    static createFrom(source: any = {}) {
	        return new FindExtra(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.order_by_column = source["order_by_column"];
	        this.order_by_desc = source["order_by_desc"];
	        this.limit = source["limit"];
	        this.offset = source["offset"];
	    }
	}
	export class PointsRecordListDtoExtra {
	    order_by_column?: string;
	    order_by_desc?: boolean;
	    limit?: number;
	    offset?: number;
	
	    static createFrom(source: any = {}) {
	        return new PointsRecordListDtoExtra(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.order_by_column = source["order_by_column"];
	        this.order_by_desc = source["order_by_desc"];
	        this.limit = source["limit"];
	        this.offset = source["offset"];
	    }
	}
	export class RequestAppAdd {
	    tool_name?: string;
	    tool_icon?: string;
	    tool_icon_color?: string;
	    prompt?: string;
	    input_count?: number;
	    share_status: number;
	    share_user_id: number;
	    tag_ids: string;
	    complete_do?: string;
	
	    static createFrom(source: any = {}) {
	        return new RequestAppAdd(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.input_count = source["input_count"];
	        this.share_status = source["share_status"];
	        this.share_user_id = source["share_user_id"];
	        this.tag_ids = source["tag_ids"];
	        this.complete_do = source["complete_do"];
	    }
	}
	export class RequestAppUpdate {
	    app_id: number;
	    use_nums?: number;
	    start_nums?: number;
	
	    static createFrom(source: any = {}) {
	        return new RequestAppUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.app_id = source["app_id"];
	        this.use_nums = source["use_nums"];
	        this.start_nums = source["start_nums"];
	    }
	}
	export class UserDtoInfo {
	    id?: number;
	    qq_id?: string;
	    avatar?: string;
	    qq_key?: string;
	    username?: string;
	    // Go type: time
	    yun_end: any;
	    email?: string;
	    i_dou?: number;
	    // Go type: time
	    created_at: any;
	    // Go type: time
	    updated_at: any;
	
	    static createFrom(source: any = {}) {
	        return new UserDtoInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.qq_id = source["qq_id"];
	        this.avatar = source["avatar"];
	        this.qq_key = source["qq_key"];
	        this.username = source["username"];
	        this.yun_end = this.convertValues(source["yun_end"], null);
	        this.email = source["email"];
	        this.i_dou = source["i_dou"];
	        this.created_at = this.convertValues(source["created_at"], null);
	        this.updated_at = this.convertValues(source["updated_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class UserDtoLogin {
	    password: string;
	    email: string;
	
	    static createFrom(source: any = {}) {
	        return new UserDtoLogin(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.password = source["password"];
	        this.email = source["email"];
	    }
	}
	export class UserDtoRegister {
	    password: string;
	    username: string;
	    email: string;
	    email_code: string;
	
	    static createFrom(source: any = {}) {
	        return new UserDtoRegister(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.password = source["password"];
	        this.username = source["username"];
	        this.email = source["email"];
	        this.email_code = source["email_code"];
	    }
	}

}

export namespace dbdto {
	
	export class ChatContentInfo {
	    id: number;
	    sender_role: string;
	    is_handing: boolean;
	    content: string;
	    tool_id: number;
	    chat_dialog_id: number;
	    is_error: boolean;
	    error_msg: string;
	    use_time: number;
	    // Go type: time
	    created_at: any;
	
	    static createFrom(source: any = {}) {
	        return new ChatContentInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.sender_role = source["sender_role"];
	        this.is_handing = source["is_handing"];
	        this.content = source["content"];
	        this.tool_id = source["tool_id"];
	        this.chat_dialog_id = source["chat_dialog_id"];
	        this.is_error = source["is_error"];
	        this.error_msg = source["error_msg"];
	        this.use_time = source["use_time"];
	        this.created_at = this.convertValues(source["created_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChatContentUpdate {
	    content: string;
	    is_handing: boolean;
	    is_error: boolean;
	    error_msg: string;
	    use_time: number;
	
	    static createFrom(source: any = {}) {
	        return new ChatContentUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.content = source["content"];
	        this.is_handing = source["is_handing"];
	        this.is_error = source["is_error"];
	        this.error_msg = source["error_msg"];
	        this.use_time = source["use_time"];
	    }
	}
	export class ChatDialogInfo {
	    id: number;
	    tool_id: number;
	    tool_name: string;
	    tool_icon: string;
	    tool_icon_color: string;
	    clips: string;
	    first_content: string;
	    // Go type: time
	    created_at: any;
	
	    static createFrom(source: any = {}) {
	        return new ChatDialogInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.tool_id = source["tool_id"];
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.clips = source["clips"];
	        this.first_content = source["first_content"];
	        this.created_at = this.convertValues(source["created_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ChatDialogSelect {
	    list: ChatDialogInfo[];
	    total: number;
	    curr_page: number;
	    page_size: number;
	
	    static createFrom(source: any = {}) {
	        return new ChatDialogSelect(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ChatDialogInfo);
	        this.total = source["total"];
	        this.curr_page = source["curr_page"];
	        this.page_size = source["page_size"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ClipboardAdd {
	    content: string;
	
	    static createFrom(source: any = {}) {
	        return new ClipboardAdd(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.content = source["content"];
	    }
	}
	export class ClipboardInfo {
	    id: number;
	    content: string;
	    from?: string;
	    // Go type: time
	    created_at: any;
	
	    static createFrom(source: any = {}) {
	        return new ClipboardInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.content = source["content"];
	        this.from = source["from"];
	        this.created_at = this.convertValues(source["created_at"], null);
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ClipboardSelect {
	    list: ClipboardInfo[];
	    total: number;
	    curr_page: number;
	    page_size: number;
	
	    static createFrom(source: any = {}) {
	        return new ClipboardSelect(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.list = this.convertValues(source["list"], ClipboardInfo);
	        this.total = source["total"];
	        this.curr_page = source["curr_page"];
	        this.page_size = source["page_size"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ConfigAdd {
	    config_key: string;
	    config_value: string;
	    config_type: string;
	
	    static createFrom(source: any = {}) {
	        return new ConfigAdd(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.config_key = source["config_key"];
	        this.config_value = source["config_value"];
	        this.config_type = source["config_type"];
	    }
	}
	export class ConfigInfo {
	    id?: number;
	    // Go type: time
	    created_at: any;
	    // Go type: time
	    updated_at: any;
	    config_key?: string;
	    config_value?: string;
	    config_type?: string;
	
	    static createFrom(source: any = {}) {
	        return new ConfigInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.created_at = this.convertValues(source["created_at"], null);
	        this.updated_at = this.convertValues(source["updated_at"], null);
	        this.config_key = source["config_key"];
	        this.config_value = source["config_value"];
	        this.config_type = source["config_type"];
	    }
	
		convertValues(a: any, classs: any, asMap: boolean = false): any {
		    if (!a) {
		        return a;
		    }
		    if (a.slice) {
		        return (a as any[]).map(elem => this.convertValues(elem, classs));
		    } else if ("object" === typeof a) {
		        if (asMap) {
		            for (const key of Object.keys(a)) {
		                a[key] = new classs(a[key]);
		            }
		            return a;
		        }
		        return new classs(a);
		    }
		    return a;
		}
	}
	export class ConfigKV {
	    config_key?: string;
	    config_value?: string;
	
	    static createFrom(source: any = {}) {
	        return new ConfigKV(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.config_key = source["config_key"];
	        this.config_value = source["config_value"];
	    }
	}
	export class ConfigUpdate {
	    id?: number;
	    config_key?: string;
	    config_value?: string;
	    config_type?: string;
	
	    static createFrom(source: any = {}) {
	        return new ConfigUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.config_key = source["config_key"];
	        this.config_value = source["config_value"];
	        this.config_type = source["config_type"];
	    }
	}
	export class UserToolAdd {
	    tool_name: string;
	    tool_icon: string;
	    tool_icon_color: string;
	    prompt: string;
	    input_count: number;
	    use_hot_key: boolean;
	    quick_pos?: number;
	    hot_key?: string;
	    complete_do?: string;
	
	    static createFrom(source: any = {}) {
	        return new UserToolAdd(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.input_count = source["input_count"];
	        this.use_hot_key = source["use_hot_key"];
	        this.quick_pos = source["quick_pos"];
	        this.hot_key = source["hot_key"];
	        this.complete_do = source["complete_do"];
	    }
	}
	export class UserToolInfo {
	    id?: number;
	    tool_name?: string;
	    tool_icon?: string;
	    tool_icon_color?: string;
	    prompt: string;
	    chat_dialog_num: number;
	    input_count?: number;
	    use_hot_key: boolean;
	    hot_key?: string;
	    quick_pos?: number;
	    complete_do?: string;
	
	    static createFrom(source: any = {}) {
	        return new UserToolInfo(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.chat_dialog_num = source["chat_dialog_num"];
	        this.input_count = source["input_count"];
	        this.use_hot_key = source["use_hot_key"];
	        this.hot_key = source["hot_key"];
	        this.quick_pos = source["quick_pos"];
	        this.complete_do = source["complete_do"];
	    }
	}
	export class UserToolUpdate {
	    id: number;
	    tool_name?: string;
	    tool_icon?: string;
	    tool_icon_color?: string;
	    prompt?: string;
	    input_count?: number;
	    use_hot_key?: boolean;
	    quick_pos?: number;
	    hot_key?: string;
	    complete_do?: string;
	
	    static createFrom(source: any = {}) {
	        return new UserToolUpdate(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.input_count = source["input_count"];
	        this.use_hot_key = source["use_hot_key"];
	        this.quick_pos = source["quick_pos"];
	        this.hot_key = source["hot_key"];
	        this.complete_do = source["complete_do"];
	    }
	}

}

export namespace dto {
	
	export class Pos {
	    pos_x: number;
	    pos_y: number;
	
	    static createFrom(source: any = {}) {
	        return new Pos(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.pos_x = source["pos_x"];
	        this.pos_y = source["pos_y"];
	    }
	}
	export class RespData {
	    code: number;
	    msg: string;
	    data: any;
	
	    static createFrom(source: any = {}) {
	        return new RespData(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = source["data"];
	    }
	}

}

export namespace entity {
	
	export class UserTool {
	    id?: number;
	    tool_name?: string;
	    tool_icon?: string;
	    tool_icon_color?: string;
	    prompt?: string;
	    input_count?: number;
	    quick_pos?: number;
	    hot_key?: string;
	    use_hot_key?: boolean;
	    complete_do?: string;
	
	    static createFrom(source: any = {}) {
	        return new UserTool(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.id = source["id"];
	        this.tool_name = source["tool_name"];
	        this.tool_icon = source["tool_icon"];
	        this.tool_icon_color = source["tool_icon_color"];
	        this.prompt = source["prompt"];
	        this.input_count = source["input_count"];
	        this.quick_pos = source["quick_pos"];
	        this.hot_key = source["hot_key"];
	        this.use_hot_key = source["use_hot_key"];
	        this.complete_do = source["complete_do"];
	    }
	}

}

export namespace service {
	
	export class HttpResp {
	    code: number;
	    msg: string;
	    data: any;
	    extra?: any;
	
	    static createFrom(source: any = {}) {
	        return new HttpResp(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.code = source["code"];
	        this.msg = source["msg"];
	        this.data = source["data"];
	        this.extra = source["extra"];
	    }
	}
	export class ScreenSize {
	    width: number;
	    height: number;
	
	    static createFrom(source: any = {}) {
	        return new ScreenSize(source);
	    }
	
	    constructor(source: any = {}) {
	        if ('string' === typeof source) source = JSON.parse(source);
	        this.width = source["width"];
	        this.height = source["height"];
	    }
	}

}

